package com.mazaiting.common.core.utils;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.CollectionUtil;

import java.security.SecureRandom;
import java.util.*;

/**
 * 字符串工具类
 *
 * @author mazaiting
 * @date 2021-11-4
 */
public class StringUtil {

    /**
     * 判断文本是否为空
     *
     * @param text 文本
     * @return true: 为空; false: 不为空
     */
    public static boolean isEmpty(String text) {
        return null == text || "".equals(text) || text.length() == 0;
    }

    /**
     * 判断文本是否为空
     *
     * @param text 文本
     * @return true: 不为空; false: 为空
     */
    public static boolean isNotEmpty(String text) {
        return null == text || "".equals(text);
    }

    /**
     * 判断文本是否为空
     *
     * @param str 文本
     * @return true: 为空; false: 不为空
     */
    public static boolean isEmpty(CharSequence str) {
        return null == str || str.length() == 0;
    }

    /**
     * 判断文本是否为空
     *
     * @param str 文本
     * @return true: 不为空; false: 为空
     */
    public static boolean isNotEmpty(CharSequence str) {
        return !isEmpty(str);
    }

    /**
     * 生成32位随机字符串
     *
     * @return 32位随机字符串
     */
    public static String getUUID() {
        return UUID.randomUUID().toString().trim().replaceAll("-", "");
    }

    /**
     * 如果文本是空, 则使用默认值
     *
     * @param text        文本
     * @param defaultText 默认文本
     * @return 文本
     */
    public static String defaultIfEmpty(String text, String defaultText) {
        // 如果默认为null, 则设置为空
        if (Objects.isNull(defaultText)) {
            defaultText = "";
        }
        return StringUtil.isEmpty(text) ? text : defaultText;
    }

    /**
     * 获取随机数字符串
     *
     * @param num 位数
     * @return num 位随机数
     */
    public static String getRandomString(int num) {
        SecureRandom secureRandom = new SecureRandom();
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < num; i++) {
            builder.append(secureRandom.nextInt(10));
        }
        return builder.toString();
    }

    /**
     * 替换字段
     *
     * @param content 短信内容
     * @param map     字段替换集合
     * @return 替换后的短信内容
     */
    public static String replaceField(String content, Map<String, String> map) {
        if (CollectionUtil.isNotEmpty(map)) {
            for (Map.Entry<String, String> entry : map.entrySet()) {
                content = content.replace(entry.getKey(), entry.getValue());
            }
        }
        return content;
    }


    /**
     * 忽略大小写包含
     *
     * @param str         字符串
     * @param testStrList 列表
     * @return true: 包含; false: 不包含
     */
    public static boolean containsIgnoreCase(CharSequence str, Collection<? extends CharSequence> testStrList) {
        return null != getContainsStrIgnoreCase(str, testStrList);
    }


    /**
     * 忽略大小写包含
     *
     * @param str         字符串
     * @param testStrList 列表
     * @return true: 包含; false: 不包含
     */
    public static String getContainsStrIgnoreCase(CharSequence str, Collection<? extends CharSequence> testStrList) {
        if (isEmpty(str) || CollUtil.isEmpty(testStrList)) {
            return null;
        }
        CharSequence[] array = testStrList.toArray(new CharSequence[0]);
        int size = testStrList.size();
        for (int i = 0; i < size; ++i) {
            CharSequence testStr = array[i];
            if (containsIgnoreCase(str, testStr)) {
                return testStr.toString();
            }
        }
        return null;
    }

    /**
     * 忽略大小写包含
     *
     * @param str     字符串
     * @param testStr 列表
     * @return true: 包含; false: 不包含
     */
    public static boolean containsIgnoreCase(CharSequence str, CharSequence testStr) {
        if (null == str) {
            return null == testStr;
        }
        return str.toString().toLowerCase().contains(testStr.toString().toLowerCase());
    }


    /**
     * 将数组转换为字符串
     *
     * @param prefix    前缀
     * @param suffix    后缀
     * @param delimiter 分隔符
     * @param elements  数组元素
     * @return 字符串
     */
    public static String join(String prefix, String suffix, String delimiter, Object[] elements) {
        StringBuilder builder = new StringBuilder();
        // 拼接前缀
        if (isNotEmpty(prefix)) builder.append(prefix);
        // 只有存在元素的情况下才进行拼接
        if (Objects.nonNull(elements) && elements.length > 0) {
            for (int i = 0; i < elements.length; i++) {
                // 不是第一个则拼接分隔符
                if (i != 0) {
                    builder.append(delimiter);
                }
                builder.append(elements[i]);
            }
        }
        // 拼接后缀
        if (isNotEmpty(suffix)) builder.append(suffix);
        return builder.toString();
    }
}
